/**
 *
 *@author Sayes Lucero, Alfredo Andrès Lu:66604
 * @author Diego Ghilardi Lu: 51782
 */
package Asintactico;

import ASintactico.ASintactico;
import Alexico.analizadorLex;

import Alexico.token;
import java.io.*;

/**
 * Clase auxiliar para realizar llamadas al {@link analizadorLex}
 * @author Sayes Lucero, Alfredo Andrès Lu:66604
 * @author Diego Ghilardi Lu: 51782
 */
public class Main {

    private FileWriter salida;
    private String args0;
    private String args1;
    private boolean porArchivo = false;
    private ASintactico aSint;
    // archivo de salida, en caso que se haya ingresado uno

    /**
     * Método estático que verifica la cantidad argumentos que son pasado y decide
     * donde será mostrado el resultado de analizar lexicalmente el programa fuente. Crea el Objeto Main
     * @param args contendra el nombre de larchivo fuente a analizar y opcionalmente el archivo destino con informaicion acerca del analisis
     * de analizar el archivo fuente
     * 
     */
    public static void main(String[] args) {
        String arg;


        Main m;
        System.out.print("Entre a main");
        if ((args.length > 2) || (args.length < 1)) {
            try {
                javax.swing.JFileChooser eligearch = new javax.swing.JFileChooser();
                eligearch.showOpenDialog(eligearch);
                String camino = eligearch.getSelectedFile().getAbsolutePath();
                if (camino != null) {
                    m = new Main(camino, "");
                }
            } catch (NullPointerException e) {
                System.out.println("Cantidad de argumentos invalido");
                System.out.println("<PROGRAM_NAME> <IN_FILE>");
                System.out.println("<PROGRAM_NAME> <IN_FILE> <OUT_FILE>");
                System.exit(0);
            } catch (Exception e) {
                System.out.println("Error en la lectura");
                System.exit(0);
            }
        }
        if (args.length == 2) {
            try {
                m = new Main(args[0], args[1]);
            } catch (Exception ex) {
                System.out.println("Error en la lectura 2 argumentos");
                System.exit(0);
            }
        } else {
            if (args.length == 1) {
                try {
                    m = new Main(args[0], "");
                } catch (Exception ex) {
                    System.out.println("Error en la lectura con 1 argumento : " + ex.getMessage());
                    System.exit(0);
                }
            }
        }
    }//main

    /**
     * Setea los nombres de archivos pasados por parametros y los almacena en la clase. Es el encargado
     * de comenzar las solicitudes de tokens a travez de la llamada a un metodo privado llamado bigbang.
     * El metodo privado bigbang() itera hasta que el analizador lexico devuelve null, es decir llego al fin de archivo
     * 
     * @param args00 Nombre del archivo a analizar
     * @param args01 NOmbre opcional del archivo donde se almacenaran los resultados del analisis 
     */
    public Main(String args00, String args01) {
        this.args0 = args00;
        this.args1 = args01;
        this.bigbang();
    }//constructor

    /**
     * Solicita Tokens al {@link analizadorLex} mientras no sea fin de archivo.
     * Esta informacion se obtiene cuando el analizador Lexico retorna null.
     */
    private void bigbang() {
        try {
            token Token;
            String Linea;
            boolean archivoValido = false;
            if (!args1.equals("")) {
                porArchivo = true;
                String outfile = args1;
                crearFichero(outfile);
                System.out.println(outfile);
            }//if*/
           // else {
                /*
                System.out.println("**************************************************");
                System.out.println("*        LISTA DE TOKENS                         *");
                System.out.println("**************************************************");
                 * 
                 */
           // }
            if (args0 != null) {
                aSint = new ASintactico(args0);
            }
        } catch (Exception e) {
            System.out.println("error");
        }
    }//fin de bigbang

    /**
     * Este método crea el archivo de salida
     * @param fichero Nombre del archivo que ingreso el usuario.Debe ser un nombre valido sino genera una excepción
     */
    private void crearFichero(String fichero) {
        System.out.println(fichero);
        try {
            salida = new FileWriter(fichero, true);
            salida.write("**********************************************************\r\n");
            salida.write("*                LISTA DE TOKENS                         *\r\n");
            salida.write("**********************************************************\r\n");
            System.out.println("El archivo se ha creado correctamente");
        }//try
        catch (IOException ioe) {
            ioe.printStackTrace();
        }//catch
    }//crearFichero

    /**
     * Este Método, recibe 3 parametros:  el nombre del token, lexema y un entero,
     * representando el nùmero de lìnea del archivo. Formate esteticamente una lina para ser impresa
     * la que luego serà escrita en el archivo de salida
     *@param nombreT Nombre del Token
     *@param Lexema Lexema del Token recuperado del archivo fuente
     *@param num Número de linea en la que aparece el Token
     */
    private String armarLinea(String nombreT, String Lexema, int num) {
        String linea;
        Integer aux = new Integer(num);
        String auxiliar = aux.toString();
        String Arraynum = "";
        String ArrayNom = "";
        String ArrayLex = "";
        int largoNum, largoNom, largoLex;
        largoNum = auxiliar.length();
        if (nombreT == null) {
            nombreT = "";
            largoNom = 0;
        } else {
            largoNom = nombreT.length();
        }
        largoLex = Lexema.length();
        for (int i = 0; i < largoNum; i++) {
            Arraynum = Arraynum + auxiliar.charAt(i);
        }
        for (int i = largoNum; i < 4; i++) {
            Arraynum = Arraynum + " ";
        }
        for (int i = 0; i < largoNom; i++) {
            ArrayNom = ArrayNom + nombreT.charAt(i);
        }
        for (int i = largoNom; i < 13; i++) {
            ArrayNom = ArrayNom + " ";
        }
        for (int i = 0; i < largoLex; i++) {
            ArrayLex = ArrayLex + Lexema.charAt(i);
        }
        for (int i = largoLex; i < 13; i++) {
            ArrayLex = ArrayLex + " ";
        }
        linea = "Linea:" + Arraynum + "  " + "Token:" + ArrayNom + "  " + "Lexema:" + ArrayLex;
        return linea;
    }

    /**
     * Método encargado de cerar el archivo destino en caso de existir
     */
    private void cerrarArchivo() {
        try {
            if (porArchivo) {
                salida.close();
            }
        } catch (IOException ioe) {
            ioe.printStackTrace();
        }//catch
    }

    /**
     * Metodo
     */
    private void imprimir(String linea)/* imprime la linea en un archivo o pantalla*/ {
        if (porArchivo && salida != null) {
            try {
                if (linea != null) {
                    salida.write("\r\n");
                    salida.write(linea);
                }

            }//try
            catch (IOException ioe) {
                ioe.printStackTrace();
            }//catch
        }//if
        else {
            if (linea != null) {
                System.out.println(linea);
            }
        }
    }
    /*
    private boolean verificarArchivoLectura(String nomArch)
    {
    boolean existioError=false;
    lexico=new analizadorLex(nomArch);
    existioError=lexico.isErrorLectura();
    if(existioError)
    {
    System.out.println("error de lectura en el archivo de lectura");
    }
    return !existioError;
    }
    
     */

    /*
    private token solicitarToken() 
    {
    token t=null;
    try{
    t=lexico.getToken();
    }
    catch(Exception e)
    {
    System.out.println(e.getMessage());
    }
    return t;
    }
     */
}//class